home *** CD-ROM | disk | FTP | other *** search
/ Young Minds / Young Minds Interactive CD-ROM.ISO / adl / adlcomp / adlobj.c < prev    next >
Encoding:
C/C++ Source or Header  |  1987-08-05  |  6.7 KB  |  299 lines
  1.     /***************************************************************\
  2.     *                                *
  3.     *    adlobj.c - routines dealing with the compilation of    *
  4.     *    object declaractions and assigments.            *
  5.     *    Copyright 1987 by Ross Cunniff.                *
  6.     *                                *
  7.     \***************************************************************/
  8.  
  9. #include <stdio.h>
  10.  
  11. #include "adltypes.h"
  12. #include "adlprog.h"
  13. #include "adldef.h"
  14. #include "adlcomp.h"
  15.  
  16.  
  17.     /***************************************************************\
  18.     *                                *
  19.     *    noun_exists( adj, noun ) - returns an object ID iff    *
  20.     *    an object exists with noun ID noun and adjective id    *
  21.     *    adj.  Returns -1 otherwise.                *
  22.     *                                *
  23.     \***************************************************************/
  24.  
  25. int16
  26. noun_exists( adj, noun )
  27. int16
  28.     adj,
  29.     noun;
  30. {
  31.     int16
  32.     t;
  33.  
  34.     for( t = nounspace[ noun ]; t != 0; t = objspace[ t ].others )
  35.     if( objspace[ t ].adj == adj )
  36.         return t;
  37.     return -1;
  38. }
  39.  
  40.  
  41.     /***************************************************************\
  42.     *                                *
  43.     *    move_obj( obj, dest ) - moves object obj to object    *
  44.     *    dest, taking care to put obj at the END of the list    *
  45.     *    of objects contained in dest.                *
  46.     *                                *
  47.     \***************************************************************/
  48.  
  49. move_obj( obj, dest )
  50. int16
  51.     obj, dest;
  52. {
  53.     int16
  54.     t;
  55.  
  56.     /* Find the object whose link is obj (if any) */
  57.     t = objspace[ obj ].loc;
  58.     if( objspace[ t ].cont != obj ) {
  59.     /* Obj must be a link */
  60.     t = objspace[ t ].cont;
  61.     while( objspace[ t ].link != obj )
  62.         t = objspace[ t ].link;
  63.     objspace[ t ].link = objspace[ objspace[ t ].link ].link;
  64.     }
  65.     else
  66.     /* Obj is the head of the list. */
  67.     objspace[ t ].cont = objspace[ objspace[ t ].cont ].link;
  68.  
  69.     /* Seek to the end of the list and place obj there. */
  70.     objspace[ obj ].loc = dest;
  71.     t = objspace[ dest ].cont;
  72.     objspace[ obj ].link = 0;
  73.     if( t ) {
  74.     /* Jump to the end of the list */
  75.     while( objspace[ t ].link )
  76.         t = objspace[ t ].link;
  77.     objspace[ t ].link = obj;
  78.     }
  79.     else
  80.     /* There is nothing in the list. */
  81.     objspace[ dest ].cont = obj;
  82. }
  83.  
  84.  
  85.     /***************************************************************\
  86.     *                                *
  87.     *    new_noun( mod, noun ) - create a new object with    *
  88.     *    modifier list mod and noun ID noun.  The object is    *
  89.     *    initially placed in .ALL.                *
  90.     *                                *
  91.     \***************************************************************/
  92.  
  93. int16
  94. new_noun( mod, noun )
  95. int16
  96.     mod, noun;
  97. {
  98.     int16
  99.     obj;
  100.  
  101.     obj = NUMOBJ++;
  102.     objspace[ obj ].others = nounspace[ noun ];
  103.     nounspace[ noun ] = obj;
  104.     objspace[ obj ].loc = _ALL;
  105.     objspace[ obj ].link = objspace[ _ALL ].cont;
  106.     objspace[ _ALL ].cont = obj;
  107.     objspace[ obj ].adj = mod;
  108.     objspace[ obj ].noun = noun;
  109.     return obj;
  110. } 
  111.  
  112.  
  113.     /***************************************************************\
  114.     *                                *
  115.     *    getnew( t_read ) - read a new modified object from the    *
  116.     *    token stream and return its id.    t_read is nonzero    *
  117.     *    iff the first token in the list has already been read.    *
  118.     *                                *
  119.     \***************************************************************/
  120.  
  121. int16
  122. getnew( t_read )
  123. int16
  124.     t_read;
  125. {
  126.     int16
  127.     t_save;
  128.  
  129.     if( !t_read )
  130.     lexer();
  131.     if( t_type == VERB ) {
  132.     t_val = -t_val;
  133.     t_type = ADJEC;
  134.     }
  135.     if( t_type == ADJEC ) {
  136.     t_save = t_val;
  137.     lexer();
  138.     if( t_type == UNDECLARED ) {
  139.         insertkey( token, NOUN, NUMNOUN, 1 );
  140.         return new_noun( t_save, NUMNOUN++ );
  141.     }
  142.     else if( t_type == NOUN ) {
  143.         if(        (noun_exists( t_save, t_val ) >= 0) ||
  144.             (noun_exists( 0, t_val ) >= 0) )
  145.         error( "Attempt to redeclare a noun.\n" );
  146.         else
  147.         return new_noun( t_save, t_val );
  148.     }
  149.     else
  150.         error( NOUN_WANTED );
  151.     }
  152.     else if( t_type == UNDECLARED ) {
  153.     insertkey( token, NOUN, NUMNOUN, 1 );
  154.     return new_noun( 0, NUMNOUN++ );
  155.     }
  156.     else
  157.     error( ILLEGAL_SYMBOL );
  158.     return -1;
  159. }
  160.  
  161.  
  162.     /***************************************************************\
  163.     *                                *
  164.     *    getold( t_read, t_save ) - read a previously declared    *
  165.     *    object from the token string.  t_read is the number    *
  166.     *    of tokens already read, and t_save is the value of the    *
  167.     *    previous token (if such exists).            *
  168.     *                                *
  169.     \***************************************************************/
  170.  
  171. int16
  172. getold( t_read, t_save )
  173. int16
  174.     t_read,
  175.     t_save;
  176. {
  177.     if( t_read == 0 )
  178.     lexer();
  179.     if( t_read != 2 ) {
  180.     if( t_type == NOUN_SYN )
  181.         return t_val;
  182.     if( t_type == VERB ) {
  183.         t_type = ADJEC;
  184.         t_val = -t_val;
  185.     }
  186.     if( t_type == ADJEC ) {
  187.         t_save = t_val;
  188.         lexer();
  189.     }
  190.     }
  191.     if( t_type != NOUN ) {
  192.     error( ILLEGAL_SYMBOL );
  193.     return -1;
  194.     }
  195.     if( (t_save = noun_exists( t_save, t_val )) < 0 )
  196.     error( ATTEMPT );
  197.     return t_save;
  198. }
  199.  
  200.  
  201.     /***************************************************************\
  202.     *                                *
  203.     *    setprop( obj, which, val ) - set the which'th property    *
  204.     *    of object obj to be val.                *
  205.     *                                *
  206.     \***************************************************************/
  207.  
  208. setprop( obj, which, val )
  209. int16
  210.     obj,
  211.     which,
  212.     val;
  213. {
  214.     static char
  215.     *ALREADY = "Noun property already assigned.\n";
  216.  
  217.     if( (which >=1) && (which <= 16) ) {
  218.     /* Boolean property */
  219.     if( objspace[ obj ].props1to16 & bitpat[ which - 1 ] )
  220.         warning( ALREADY );
  221.     if( val )
  222.         objspace[ obj ].props1to16 |= bitpat[ which - 1 ];
  223.     else
  224.         objspace[ obj ].props1to16 &= ibitpat[ which - 1 ];
  225.     }
  226.     else if( (which >= 17) && (which <= _ACT ) ) {
  227.     if( objspace[ obj ].props[ which - 17 ] )
  228.         warning( ALREADY );
  229.     objspace[ obj ].props[ which - 17 ] = val;
  230.     }
  231.     else
  232.     error( "Invalid object property number.\n" );
  233. }
  234.   
  235.  
  236. /***************************************************************\
  237. *                                *
  238. *    nounassign( t_read, t_save ) - parse and interpret a    *
  239. *    noun property assignment.                *
  240. *                                *
  241. \***************************************************************/
  242.  
  243. nounassign( t_read, t_save )
  244. int16
  245.     t_read,
  246.     t_save;
  247. {
  248.     int16
  249.     obj,
  250.     which,
  251.     getassign();
  252.  
  253.     obj = getold( t_read, t_save );
  254.     lexer();
  255.     if( t_type != '(' )
  256.     _ERR_FIX( LEFT_EXPECTED, ';' );
  257.     lexer();
  258.     if( t_type != CONST )
  259.     _ERR_FIX( CONST_EXPECTED, ';' );
  260.     which = t_val;
  261.     lexer();
  262.     if( t_type != ')' )
  263.     _ERR_FIX( RIGHT_EXPECTED, ';' );
  264.     setprop( obj, which, getassign( 0 ) );
  265. }
  266.  
  267.  
  268.     /***************************************************************\
  269.     *                                *
  270.     *    getnouns() - parse and interpret a NOUN declaration.    *
  271.     *                                *
  272.     \***************************************************************/
  273.  
  274. getnouns()
  275. {
  276.     int16
  277.     obj, loc;
  278.  
  279.     while( t_type != ';' ) {
  280.     if( (obj = getnew( 0 )) >= 0 ) {
  281.         lexer();
  282.         if( t_type == '(' ) {
  283.         loc = getold( 0, 0 );
  284.         move_obj( obj, loc );
  285.         lexer();
  286.         if( t_type != ')' )
  287.             _ERR_FIX( RIGHT_EXPECTED, ';' );
  288.         lexer();
  289.         }
  290.         else if( (t_type != ',') && (t_type != ';') )
  291.         _ERR_FIX( COMMA_EXPECTED, ';' );
  292.     }
  293.     else
  294.         eatuntil( ';' );
  295.     }
  296. }
  297.  
  298. /*** EOF adlobj.c ***/
  299.